Shape3D.cpp

           

            Dans cette partie, vous allez sous classer et implémenter Shape3D en deux classes :

ShapeCubic et Pyramid. Les définitions sont fournises plus bas :

 

ShapeCubic.h

Pyramid.h

           

            Un objet de type ShapeCubic crée un objet cubic à partir de deux Trapezius (Base et Top)

            Un objet de type Pyramid crée un objet pyramidal à partir d’un Trapezius  (la base) et de la hauteur du point sommet par rapport

            à la base.

           

 

Partie 2 (15pts) :

Dans cette partie, vous allez créer votre propre hiérarchie de sous-classes 3D, et les utilisez (ainsi que celles de la première partie) pour construire un modèle de votre choix. Par exemple, vous pourriez créer une maison à partir d’objets briques, fenêtres et toit.

           

            Pour cette partie, vous n’êtes limité que par votre créativité. À vous de m’impressionner.

 

 

Comme d’habitude, je m’attend à ce que toutes mémoire allouée dynamiquement soit gérée correctement.

Vous pouvez utiliser le fichier exemple comme point de départ pour votre main. (vous n’avez besoin de modifier que l’intérieur de la fonction DrawGLScene)

pour rendre vos objets.

 

Exemple basé sur ce main (essayer les touches arrow, q, w, a, s, z, x)

 

 

 

10 pt Q2:

 

La classe UnTruc est définit de la manière suivante :

 

class UnTruc

{

 

private:

          int verts;

     Etoiles *points;

          void readstr(FILE *f,char *string); // Reads A String From File (f)

 

public:

          UnTruc(void);

          UnTruc(const UnTruc&); //Cconstructeur par défaut

 

     void EtoilesAllocate(int n);     

// Alloue n espaces mémoires de taille sizeof(Etoiles),

// qui seront référencés par points

    

void Load(char *name); 

// Cree un objet a partir d’un fichier de coordonnées

    

void SetPoint(int i, float x, float y, float z);

          //Assigne les coordonnées (x, y, z) à points[i]

 

void SetPoint(int i, Etoiles E);

          //Assigne E à points[i]

         

     Etoiles GetPoint(int i){return points[i];}

         

          const UnTruc& operator=(const UnTruc&);

          //Operateur d’assignation

 

     int getVerts(){return verts;};

    

          static Etoiles Calculate(UnTruc* sour, UnTruc* dest, int i, int steps);

// Calcule le mouvement des points pendant le morphing

    

          ~UnTruc(void);

};

 

 

Où  Etoiles* points représente un tableau d’objets de type Etoiles, dont la classe est définie comme suit :

 

class Etoiles

{

 

public:

          float     x, y, z;      // X, Y & Z Points

public:

          Etoiles(void);         

//Cree un point dont les coordonnées sont (0,0,0)   

     Etoiles(float a, float b, float c);

          //Cree un point dont les coordonnées sont (a,b,c)

 

     Etoiles operator-(Etoiles x);

          Etoiles operator+(Etoiles x);

     Etoiles operator*(Etoiles x);

          Etoiles operator/(Etoiles x);

 

     ~Etoiles(void);

};

 

 

Pour cette question, vous allez devoir implémenter les méthodes de deux classes UnTruc et Etoiles.

Nous avons vu des exemples de chaque méthodes auparavant, à part pour les méthodes décrites ci-dessous :

 

Pour implémenter les méthodes suivantes :

 

void UnTruc::readstr(FILE *f,char *string);

void UnTruc::Load(char *name);   

 

vous allez avoir besoin d’ouvrir et de lire des fichiers de donnés. 

La manière la plus simple est d’utiliser les fonctions suivantes, définies dans <stdio.h> :

 

fopen(name, "rt");

// Ouvre le fichier qui s’appelle name pour lecture en mode translation.

// retourne un pointeur à un fichier                                             

// CTRL symbolise la fin du fichier

 

fgets(string, n, f);   

// Lit n caractère du fichier pointé par f et les places dans string

 

sscanf(oneline, "Vertices: %d\n", &ver);  

// cherche une partie de texte dans le premier argument qui est dans le mème format

// que le deuxième argument, et place les variables designées dans les arguments suivants

 

fclose(f); //ferme le fichier pointé par f

 

Vous trouverez plus d’info sur ces fonctions ici :

fopen

sscanf

fgets

 

Lorsque que la méthode X.Load(name)est appelée sur un objet X de type UnTruc, X ira ouvrir un fichier de donnée, lira la première ligne

pour obtenir le nombre de points dont le truc est composé, et allouera un espace mémoire correspondant à points. Ensuite, la fonction utilisera readstr

pour lire les lignes du fichier en séquence (chaque ligne représentant les coordonnées d’un points), et assignera les coordonnées de chaque points au éléments

correspondant de son tableau interne d’Etoiles.

 

 

La méthode static suivante :

 static Etoiles Calculate(UnTruc* sour, UnTruc* dest, int i, int steps);

// Calcule le mouvement des points pendant le morphing

 

Calcule et retourne un point intermédiaire entre la ième Etoiles du truc pointé par sour et la ième Etoile du truc pointé par dest.  Steps correspond au nombre de divisions entre les deux points. Cette fonction est utilisée pour faire une jolie transition entre les trucs qui sont loadés en succession.

 

Vous serez pénalisé pour toutes fuite de mémoire.

 

Pour cette question, vous ne me rendrez que les fichiers Etoiles.cpp et UnTruc.cpp, en format texte.

 

Votre implémentation sera utilisé dans le programme dont le main est ici.

Les fichiers de donnés utilisé par ce programme se trouve ici

Un exemple du résultat final se trouve ici.

 

 

5 pt Q3 :  Décrivez les différences entre un constructeur par défaut et une surcharge d’opérateur d’assignation. Parlez des conséquences potentielles

de ne pas les définir lors de la déclaration d’une classe. Expliquez pourquoi je n’ai pas trouvé nécessaire de vous demander d’en définir pour la class Etoile

de la deuxième question de ce devoir.